package com.example.lin.day10_12_baidumap;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.support.v7.app.AlertDialog;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;

import com.baidu.location.BDAbstractLocationListener;
import com.baidu.location.BDLocation;
import com.baidu.location.LocationClient;
import com.baidu.location.LocationClientOption;
import com.baidu.location.Poi;
import com.baidu.mapapi.map.BaiduMap;
import com.baidu.mapapi.map.BitmapDescriptor;
import com.baidu.mapapi.map.BitmapDescriptorFactory;
import com.baidu.mapapi.map.MapView;
import com.baidu.mapapi.map.Marker;
import com.baidu.mapapi.map.MarkerOptions;
import com.baidu.mapapi.map.MyLocationConfiguration;
import com.baidu.mapapi.map.MyLocationData;
import com.baidu.mapapi.map.Overlay;
import com.baidu.mapapi.map.OverlayOptions;
import com.baidu.mapapi.model.LatLng;

import java.util.List;

public class MainActivity extends AppCompatActivity {

    private SensorManager sensorManager;
    private Sensor magneticSensor;
    private Sensor accelerometerSensor;
    private Sensor gyroscopeSensor;
    private Marker overlay;

    //初始化定位信息,并开启定位
    private void initLocationBaiDuApi(){
        mLocationClient = new LocationClient(getApplicationContext());
        //声明LocationClient类
        mLocationClient.registerLocationListener(myListener);
        //注册监听函数
        LocationClientOption option = new LocationClientOption();

        option.setIsNeedLocationPoiList(true);
//可选，是否需要周边POI信息，默认为不需要，即参数为false
//如果开发者需要获得周边POI信息，此处必须为true

        option.setIsNeedLocationDescribe(true);
//可选，是否需要位置描述信息，默认为不需要，即参数为false
//如果开发者需要获得当前点的位置信息，此处必须为true

        option.setIsNeedAddress(true);
//可选，是否需要地址信息，默认为不需要，即参数为false
//如果开发者需要获得当前点的地址信息，此处必须为true

        option.setLocationMode(LocationClientOption.LocationMode.Hight_Accuracy);
//可选，设置定位模式，默认高精度
//LocationMode.Hight_Accuracy：高精度；
//LocationMode. Battery_Saving：低功耗；
//LocationMode. Device_Sensors：仅使用设备；

        option.setCoorType("GCJ02");
//可选，设置返回经纬度坐标类型，默认GCJ02
//GCJ02：国测局坐标；
//BD09ll：百度经纬度坐标；
//BD09：百度墨卡托坐标；
//海外地区定位，无需设置坐标类型，统一返回WGS84类型坐标

        option.setScanSpan(3000);
//可选，设置发起定位请求的间隔，int类型，单位ms
//如果设置为0，则代表单次定位，即仅定位一次，默认为0
//如果设置非0，需设置1000ms以上才有效

        option.setOpenGps(true);
//可选，设置是否使用gps，默认false
//使用高精度和仅用设备两种定位模式的，参数必须设置为true

        option.setLocationNotify(false);
//可选，设置是否当GPS有效时按照1S/1次频率输出GPS结果，默认false

        option.setIgnoreKillProcess(true);
//可选，定位SDK内部是一个service，并放到了独立进程。
//设置是否在stop的时候杀死这个进程，默认（建议）不杀死，即setIgnoreKillProcess(true)

        option.SetIgnoreCacheException(false);
//可选，设置是否收集Crash信息，默认收集，即参数为false

        option.setWifiCacheTimeOut(5*60*1000);
//可选，V7.2版本新增能力
//如果设置了该接口，首次启动定位时，会先判断当前Wi-Fi是否超出有效期，若超出有效期，会先重新扫描Wi-Fi，然后定位

        option.setEnableSimulateGps(false);
//可选，设置是否需要过滤GPS仿真结果，默认需要，即参数为false

        mLocationClient.setLocOption(option);
        //mLocationClient为第二步初始化过的LocationClient对象
        //需将配置好的LocationClientOption对象，通过setLocOption方法传递给LocationClient对象使用
        //更多LocationClientOption的配置，请参照类参考中LocationClientOption类的详细说明

        mLocationClient.start();
        //mLocationClient为第二步初始化过的LocationClient对象
        //调用LocationClient的start()方法，便可发起定位请求
    }


    public LocationClient mLocationClient = null;
    private MyLocationListener myListener = new MyLocationListener();
    private BitmapDescriptor mCurrentMarker;
    private MyLocationConfiguration.LocationMode mCurrentMode;
    //BDAbstractLocationListener为7.2版本新增的Abstract类型的监听接口
    //原有BDLocationListener接口暂时同步保留。具体介绍请参考后文第四步的说明

    public class MyLocationListener extends BDAbstractLocationListener {

        @Override
        public void onReceiveLocation(BDLocation location){


            //此处的BDLocation为定位结果信息类，通过它的各种get方法可获取定位相关的全部结果
            //以下只列举部分获取经纬度相关（常用）的结果信息
            //更多结果信息获取说明，请参照类参考中BDLocation类中的说明
            double latitude = location.getLatitude();    //获取纬度信息
            double longitude = location.getLongitude();    //获取经度信息
            float radius = location.getRadius();    //获取定位精度，默认值为0.0f
            String coorType = location.getCoorType();
            //获取经纬度坐标类型，以LocationClientOption中设置过的坐标类型为准
            int errorCode = location.getLocType();
            //获取定位类型、定位错误返回码，具体信息可参照类参考中BDLocation类中的说明


            String addr = location.getAddrStr();    //获取详细地址信息
            String country = location.getCountry();    //获取国家
            String province = location.getProvince();    //获取省份
            String city = location.getCity();    //获取城市
            String district = location.getDistrict();    //获取区县
            String street = location.getStreet();    //获取街道信息

            String locationDescribe = location.getLocationDescribe();    //获取位置描述信息

            List<Poi> poiList = location.getPoiList();
            StringBuilder sb = new StringBuilder();
            for (Poi p: poiList                 ) {
                sb.append(p.getName()).append(";");
            }
            Log.d("BaiDu", "poi:"+sb);


            //获取周边POI信息
            //POI信息包括POI ID、名称等，具体信息请参照类参考中POI类的相关说明

            Log.d("BaiDu", "latitude:"+latitude);
            Log.d("BaiDu", "longitude:"+longitude);
            Log.d("BaiDu", "radius:"+radius);
            Log.d("BaiDu", "coorType:"+coorType);
            Log.d("BaiDu", "errorCode:"+errorCode);


            Log.d("BaiDu", "addr:"+addr);
            Log.d("BaiDu", "country:"+country);
            Log.d("BaiDu", "province:"+province);
            Log.d("BaiDu", "city:"+city);
            Log.d("BaiDu", "district:"+district);
            Log.d("BaiDu", "street:"+street);
            Log.d("BaiDu", "locationDescribe:"+locationDescribe);
            Log.w("BaiDu", "**************************************************************" );
//            new AlertDialog.Builder(MainActivity.this).
//                    setMessage("您当前所在的城市为:"+city+",是都定位当该城市?").setPositiveButton("确定",null)
//                    .setNegativeButton("取消",null).show();
            startBaiduMapLoc(location);




            overlay.setPosition(new LatLng(latitude-(k-=0.5f),longitude));
        }

        float k = 0f;

    }


    private void startBaiduMapLoc(BDLocation location){

// 构造定位数据
        MyLocationData locData = new MyLocationData.Builder()
                .accuracy(location.getRadius())
                // 此处设置开发者获取到的方向信息，顺时针0-360
                .direction(0).latitude(location.getLatitude())
                .longitude(location.getLongitude()).build();

// 设置定位数据
        mBaiduMap.setMyLocationData(locData);

//        mCurrentMode = MyLocationConfiguration.LocationMode.FOLLOWING;//定位跟随态
        mCurrentMode = MyLocationConfiguration.LocationMode.NORMAL;   //默认为 LocationMode.NORMAL 普通态
//        mCurrentMode = MyLocationConfiguration.LocationMode.COMPASS;  //定位罗盘态

// 设置定位图层的配置（定位模式，是否允许方向信息，用户自定义定位图标）
        mCurrentMarker = BitmapDescriptorFactory.fromResource(R.mipmap.ic_launcher);

        MyLocationConfiguration config = new MyLocationConfiguration(mCurrentMode, true, mCurrentMarker);
        mBaiduMap.setMyLocationConfiguration(config);


    }

    private MapView mMapView = null;
    private BaiduMap mBaiduMap;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //获取地图控件引用
        mMapView = findViewById(R.id.bmapView);
        mBaiduMap = mMapView.getMap();//获取百度地图管理对象
        // 开启定位图层
        mBaiduMap.setMyLocationEnabled(true);

        //定义Maker坐标点
        LatLng point = new LatLng(39.963175, 116.400244);
//构建Marker图标
        Bitmap bitmap1 = BitmapFactory.decodeResource(getResources(), R.mipmap.wm);
        BitmapDescriptor bitmap = BitmapDescriptorFactory.fromBitmap(bitmap1);

//构建MarkerOption，用于在地图上添加Marker

        MarkerOptions option = new MarkerOptions()
                .position(point)
                .icon(bitmap);

//在地图上添加Marker，并显示
        overlay = (Marker) mBaiduMap.addOverlay(option);
       mBaiduMap.addOverlay(option);



        initLocationBaiDuApi();


        //陀螺仪传感器管理器
        sensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);
//        magneticSensor =sensorManager
//                .getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);
//        accelerometerSensor =sensorManager
//                .getDefaultSensor(Sensor.TYPE_ACCELEROMETER);


        gyroscopeSensor =sensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE);

        sensorManager.registerListener(new SensorEventListener() {
            private float timestamp = 0;
            private float angle[] = new float[3];
            private static final float NS2S = 1.0f / 1000000000.0f;
            private float gx = 0,gy = 0,gz = 0;
            @Override
            public void onSensorChanged(SensorEvent sensorEvent) {

                if (sensorEvent.accuracy != 0) {
                    int type = sensorEvent.sensor.getType();
                    switch (type) {
                        case Sensor.TYPE_GYROSCOPE:
                            if (timestamp != 0) {
                                final float dT = (sensorEvent.timestamp - timestamp) * NS2S;
                                angle[0] += sensorEvent.values[0] * dT;
                                angle[1] += sensorEvent.values[1] * dT;
                                angle[2] += sensorEvent.values[2] * dT;
                                float anglex = (float) Math.toDegrees(angle[0]);
                                float angley = (float) Math.toDegrees(angle[1]);
                                float anglez = (float) Math.toDegrees(angle[2]);
                            }
                            timestamp = sensorEvent.timestamp;
                            break;
                    }
                }
            }


            @Override
            public void onAccuracyChanged(Sensor sensor, int accuracy) {

            }
        },gyroscopeSensor, SensorManager.SENSOR_DELAY_GAME);


    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        //在activity执行onDestroy时执行mMapView.onDestroy()，实现地图生命周期管理
        mMapView.onDestroy();
        // 当不需要定位图层时关闭定位图层
        mBaiduMap.setMyLocationEnabled(false);
    }

    @Override
    protected void onResume() {
        super.onResume();
        //在activity执行onResume时执行mMapView. onResume ()，实现地图生命周期管理
        mMapView.onResume();
    }

    @Override
    protected void onPause() {
        super.onPause();
        //在activity执行onPause时执行mMapView. onPause ()，实现地图生命周期管理
        mMapView.onPause();
    }

    public void mapType(View view) {
        switch (view.getId()){
            case R.id.hot:
                //开启交通图
                mBaiduMap.setBaiduHeatMapEnabled(true);
                break;
            case R.id.wx:
                //卫星地图
                mBaiduMap.setMapType(BaiduMap.MAP_TYPE_SATELLITE);
                break;
            case R.id.lk:
                //开启交通图
                mBaiduMap.setTrafficEnabled(true);
                break;
            case R.id.normal:
                mBaiduMap.setMapType(BaiduMap.MAP_TYPE_NORMAL);
//普通地图 ,mBaiduMap是地图控制器对象
                break;
        }
    }

}

